package com.jeesite.modules.task.audit.web;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.jeesite.common.lang.DateUtils;
import com.jeesite.common.lang.StringUtils;
import com.jeesite.modules.annotation.RepeatSubmit;
import com.jeesite.modules.home.entity.DcSupTaskActionExplain;
import com.jeesite.modules.sys.entity.Office;
import com.jeesite.modules.sys.entity.User;
import com.jeesite.modules.sys.service.UserService;
import com.jeesite.modules.sys.utils.UserUtils;
import com.jeesite.modules.task.arrange.entity.DcSupTaskInfoArrange;
import com.jeesite.modules.task.arrange.service.DcSupTaskInfoArrangeService;
import com.jeesite.modules.task.audit.entity.DcSupTaskAuditArrangeApp;
import com.jeesite.modules.task.audit.entity.DcSupTaskAuditFeedbackApp;
import com.jeesite.modules.task.audit.entity.DcSupTaskAuditInfoApp;
import com.jeesite.modules.task.deploy.entity.DcSupTaskInfo;
import com.jeesite.modules.task.deploy.entity.DcSupTaskInfoRefine;
import com.jeesite.modules.task.deploy.service.DcSupTaskInfoRefineService;
import com.jeesite.modules.task.deploy.service.DcSupTaskInfoService;
import com.jeesite.modules.task.dict.entity.DcSupTaskInfoDict;
import com.jeesite.modules.task.dict.service.DcSupTaskInfoDictService;
import com.jeesite.modules.task.feedback.entity.DcSupTaskFeedback;
import com.jeesite.modules.utils.Dict;
import com.jeesite.modules.utils.OfficeUtil;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.jeesite.common.config.Global;
import com.jeesite.common.entity.Page;
import com.jeesite.common.web.BaseController;
import com.jeesite.modules.task.audit.entity.DcSupTaskAudit;
import com.jeesite.modules.task.audit.service.DcSupTaskAuditService;

import java.util.List;
import java.util.Map;

/**
 * 任务过程审核表Controller
 * @author zrr
 * @version 2022-03-02
 */
@Controller
@RequestMapping(value = "${adminPath}/audit/dcSupTaskAudit")
public class DcSupTaskAuditController extends BaseController {

	@Autowired
	private DcSupTaskAuditService dcSupTaskAuditService;
	@Autowired
	private DcSupTaskInfoService dcSupTaskInfoService;
	@Autowired
	private DcSupTaskInfoArrangeService dcSupTaskInfoArrangeService;
	@Autowired
	private UserService userService;
	@Autowired
	private DcSupTaskInfoDictService dcSupTaskInfoDictService;
	@Autowired
	private DcSupTaskInfoRefineService dcSupTaskInfoRefineService;
	
	/**
	 * 获取数据
	 */
	@ModelAttribute
	public DcSupTaskAudit get(String id, boolean isNewRecord) {
		return dcSupTaskAuditService.get(id, isNewRecord);
	}

	/**
	 * 查询列表 任务部署审核：deploy 任务反馈审核：feedback 任务整理审核：arrange 任务细化分解审核：refine
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:view")
	@RequestMapping(value = {"list", ""})
	public String list(DcSupTaskAudit dcSupTaskAudit, Model model, String auditType, String type) {
		// 查询条件，设置当前年
		dcSupTaskAudit.setTaskYear(DateUtils.getYear());
		List yearList = OfficeUtil.getYearList(null);

		// 查询任务类型
		DcSupTaskInfoDict dcSupTaskInfoDict = new DcSupTaskInfoDict();
		dcSupTaskInfoDict.setDictStatus("0");
		dcSupTaskInfoDict.setOrderBy("dict_sort acs");
		List<DcSupTaskInfoDict> dicts = dcSupTaskInfoDictService.findList(dcSupTaskInfoDict);

		model.addAttribute("dicts", dicts);
		model.addAttribute("yearList", yearList);
		model.addAttribute("dcSupTaskAudit", dcSupTaskAudit);

		if (auditType.equals("deploy")) {
			// 任务部署审核
			if (type.equals("done")) {
				// 已审核
				return "modules/task/audit/dcSupTaskAuditListedDeploy";
			} else {
				// 未审核
				return "modules/task/audit/dcSupTaskAuditListDeploy";
			}
		} else if (auditType.equals("feedback")) {
			// 任务反馈审核
			if (type.equals("done")) {
				// 已审核
				return "modules/task/audit/dcSupTaskAuditListedFeedback";
			} else {
				// 未审核
				return "modules/task/audit/dcSupTaskAuditListFeedback";
			}
		} else if (auditType.equals("arrange")) {
			// 任务整理审核
			if (type.equals("done")) {
				// 已审核
				return "modules/task/audit/dcSupTaskAuditListedArrange";
			} else {
				// 未审核
				return "modules/task/audit/dcSupTaskAuditListArrange";
			}
		} else {
			// 任务细化分解审核
			if (type.equals("done")) {
				// 已审核
				return "modules/task/audit/dcSupTaskAuditListedRefine";
			} else {
				// 未审核
				return "modules/task/audit/dcSupTaskAuditListRefine";
			}
		}
	}

	/**
	 * 查询列表数据 任务部署审核：deploy 任务反馈审核：feedback 任务整理审核：arrange 任务细化分解审核：refine
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:view")
	@RequestMapping(value = "listData")
	@ResponseBody
	public Page<DcSupTaskAudit> listData(DcSupTaskAudit dcSupTaskAudit, HttpServletRequest request, HttpServletResponse response) {
		dcSupTaskAudit.setPage(new Page<>(request, response));
		final Office currentOffice = OfficeUtil.getCurrentOffice();
		// 获取当前用户编号
		String userCode = UserUtils.getUser().getUserCode();
		// 过滤管理员
		if (!StringUtils.equals("system", userCode)) {
			dcSupTaskAudit.setAuditorCode(userCode);
			dcSupTaskAudit.setOfficeCode(currentOffice.getOfficeCode());
		}

		Page<DcSupTaskAudit> page = dcSupTaskAuditService.findPageByAuditType(dcSupTaskAudit);
		return page;
	}

	/**
	 * 任务部署审核，查询相同年份、标题、任务类型下的任务
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:view")
	@RequestMapping(value = "listChild")
	public String listChild(DcSupTaskAudit dcSupTaskAudit, Model model) {
		model.addAttribute("dcSupTaskAudit", dcSupTaskAudit);
		if(StringUtils.equals("1", dcSupTaskAudit.getAuditStatus())){
			// 返回待审核任务的子项
			return "modules/task/audit/dcSupTaskAuditListDeployChild";
		} else {
			// 返回已审核任务的子项
			return "modules/task/audit/dcSupTaskAuditListedDeployChild";
		}

	}

	/**
	 * 任务部署审核，查询相同年份、标题、任务类型下的任务
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:view")
	@RequestMapping(value = "listDataChild")
	@ResponseBody
	public Page<DcSupTaskAudit> listDataChild(DcSupTaskAudit dcSupTaskAudit, HttpServletRequest request, HttpServletResponse response) {
		dcSupTaskAudit.setPage(new Page<>(request, response));

		// 获取当前用户编号
		String userCode = UserUtils.getUser().getUserCode();
		// 过滤管理员
		if (!StringUtils.equals("system", userCode)) {
			dcSupTaskAudit.setAuditorCode(userCode);
		}

		Page<DcSupTaskAudit> page = dcSupTaskAuditService.getListDataChild(dcSupTaskAudit);
		return page;
	}

	/**
	 * 查询列表数据
	 */
	@RequestMapping(value = "listDataByTargetId")
	@ResponseBody
	public Page<DcSupTaskAudit> listDataByTargetId(DcSupTaskAudit dcSupTaskAudit, HttpServletRequest request, HttpServletResponse response) {
		dcSupTaskAudit.setPage(new Page<>(request, response));
		dcSupTaskAudit.setAuditStatus("2");
		dcSupTaskAudit.setOrderBy("a.audit_time desc");
		Page<DcSupTaskAudit> page = dcSupTaskAuditService.findPage(dcSupTaskAudit);
		return page;
	}

	/**
	 * 查看审核记录
	 * @param dcSupTaskAudit
	 * @param model
	 * @return
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:view")
	@RequestMapping(value = {"record", ""})
	public String record(DcSupTaskAudit dcSupTaskAudit, Model model) {
		model.addAttribute("dcSupTaskAudit", dcSupTaskAudit);
		return "modules/task/audit/dcSupTaskAuditRecord";
	}

	/**
	 * 查看审核记录数据
	 * @param dcSupTaskAudit
	 * @param request
	 * @param response
	 * @return
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:view")
	@RequestMapping(value = {"recordList", ""})
	@ResponseBody
	public Page<DcSupTaskAudit> recordList(DcSupTaskAudit dcSupTaskAudit, HttpServletRequest request, HttpServletResponse response) {
		Page page = new Page<>(request, response);
		dcSupTaskAudit.setPage(page);
		return dcSupTaskAuditService.getAuditListRecord(dcSupTaskAudit);
	}

	/**
	 * 查看编辑表单
	 * 审核表单分为5种：1任务部署普通审核、
	 * 2任务部署秘书长审核（可修改）、
	 * 3任务反馈审核（包含反馈审核人审核、科室审核、任务部署人审核）、
	 * 4任务整理审核、
	 * 5任务细化分解审核
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:view")
	@RequestMapping(value = "form")
	public String form(DcSupTaskAudit dcSupTaskAudit, Model model) {
		// 进入审核表单时，判断此审核的状态是否已审核，避免重复审核
		if(StringUtils.equals("2",dcSupTaskAudit.getAuditStatus())){
			return "modules/task/audit/dcSupTaskAuditFormError";
		}

		// 任务部署审核，任务部署细化分解审核
		if (StringUtils.equals(Dict.AuditType.TYPE_1, dcSupTaskAudit.getAuditType()) ||
				StringUtils.equals(Dict.AuditType.TYPE_7, dcSupTaskAudit.getAuditType())) {
			// 查询任务信息
			DcSupTaskInfo dcSupTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getTaskId());
			dcSupTaskInfo.setFeedbackWay(OfficeUtil.getTaskRequire(dcSupTaskInfo.getFeedbackWay(), dcSupTaskInfo.getFeedbackRate()));
			dcSupTaskAudit.setDcSupTaskInfo(dcSupTaskInfo);
			// 向页面加入审核实体
			model.addAttribute("dcSupTaskAudit", dcSupTaskAudit);
			return "modules/task/audit/dcSupTaskAuditFormTask";
		}

		// 任务部署秘书长审核
		if (StringUtils.equals(Dict.AuditType.TYPE_2, dcSupTaskAudit.getAuditType())) {
			// 查询任务信息
			DcSupTaskInfo dcSupTaskInfo =new DcSupTaskInfo();
			dcSupTaskInfo.setId(dcSupTaskAudit.getTaskId());
			dcSupTaskInfo= dcSupTaskInfoService.get(dcSupTaskInfo);
			dcSupTaskInfo.setMsgNum(dcSupTaskInfo.getMessageNumber().substring(0,dcSupTaskInfo.getMessageNumber().indexOf("〕")+1));
			dcSupTaskInfo.setMsgNum2(dcSupTaskInfo.getMessageNumber().substring(dcSupTaskInfo.getMessageNumber().indexOf("〕")+1));
			dcSupTaskAudit.setDcSupTaskInfo(dcSupTaskInfo);
			// 向页面加入审核实体
			model.addAttribute("dcSupTaskAudit", dcSupTaskAudit);

			// 查询牵头领导
			User user = new User();
			user.setRoleCode("100016");
			user.setUserType("employee");
			List<User> list = userService.findList(user);
			model.addAttribute("userList", list);

			// 查询督办人列表
			user.setRoleCode("PARTY_MEMBER");
			List<User> taskSupUser = userService.findList(user);
			model.addAttribute("taskSupUser", taskSupUser);

			// 查询督办单位
			List<Map> maps = dcSupTaskInfoService.officeSercretList();
			model.addAttribute("taskRequireOrg", maps);

			//------------------------------------------------------------------
			// 自动获取年度，近几年前台可自由配置
			Integer currentYear = Integer.parseInt(DateUtils.getYear());
			model.addAttribute("yearList", OfficeUtil.getYearList(currentYear));
			model.addAttribute("currentYear", currentYear);

			// 查询任务类型列表
			DcSupTaskInfoDict dcSupTaskInfoDict = new DcSupTaskInfoDict();
			dcSupTaskInfoDict.setDictStatus("0");
			dcSupTaskInfoDict.setOrderBy("dict_sort acs");
			List<DcSupTaskInfoDict> dicts = dcSupTaskInfoDictService.findList(dcSupTaskInfoDict);
			model.addAttribute("dicts", dicts);

			// 查询审核人为秘书长的
			user.setRoleCode("SECRETARY_GENERAL");
			List<User> auditorUserList = userService.findList(user);
			model.addAttribute("auditorUserList",auditorUserList);

			model.addAttribute("msgType", "dc_num_secret");

			return "modules/task/audit/dcSupTaskAuditFormSecretary";
		}

		// 任务反馈审核
		if (StringUtils.equals(Dict.AuditType.TYPE_3, dcSupTaskAudit.getAuditType()) ||
				StringUtils.equals(Dict.AuditType.TYPE_4, dcSupTaskAudit.getAuditType()) ||
				StringUtils.equals(Dict.AuditType.TYPE_5, dcSupTaskAudit.getAuditType())) {
			// 查询任务信息
			DcSupTaskInfo dcSupTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getTaskId());
			dcSupTaskInfo.setFeedbackWay(OfficeUtil.getTaskRequire(dcSupTaskInfo.getFeedbackWay(), dcSupTaskInfo.getFeedbackRate()));
			dcSupTaskAudit.setDcSupTaskInfo(dcSupTaskInfo);
			// 查询反馈信息
			DcSupTaskFeedback dcSupTaskFeedback = dcSupTaskAuditService.getTaskFeedbackByAudit(dcSupTaskAudit);
			dcSupTaskAudit.setDcSupTaskFeedback(dcSupTaskFeedback);
			// 向页面加入审核实体
			model.addAttribute("dcSupTaskAudit", dcSupTaskAudit);
			return "modules/task/audit/dcSupTaskAuditFormFeedback";
		}

		// 任务整理审核
		if (StringUtils.equals(Dict.AuditType.TYPE_6, dcSupTaskAudit.getAuditType())) {
			// 查询任务信息
			DcSupTaskInfo dcSupTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getTaskId());
			dcSupTaskInfo.setFeedbackWay(OfficeUtil.getTaskRequire(dcSupTaskInfo.getFeedbackWay(), dcSupTaskInfo.getFeedbackRate()));
			dcSupTaskAudit.setDcSupTaskInfo(dcSupTaskInfo);
			// 查询任务整理信息
			DcSupTaskInfoArrange dcSupTaskInfoArrange = dcSupTaskInfoArrangeService.get(dcSupTaskAudit.getTargetId());
			dcSupTaskAudit.setDcSupTaskInfoArrange(dcSupTaskInfoArrange);
			return "modules/task/audit/dcSupTaskAuditFormArrange";
		}

		// 任务细化分解审核
		if (StringUtils.equals(Dict.AuditType.TYPE_8, dcSupTaskAudit.getAuditType())) {
			// 查询任务信息
			DcSupTaskInfo dcSupTaskInfo = dcSupTaskInfoService.get(dcSupTaskAudit.getTaskId());
			dcSupTaskInfo.setFeedbackWay(OfficeUtil.getTaskRequire(dcSupTaskInfo.getFeedbackWay(), dcSupTaskInfo.getFeedbackRate()));
			// 查询任务细化分解信息
			DcSupTaskInfoRefine dcSupTaskInfoRefine = dcSupTaskInfoRefineService.get(dcSupTaskAudit.getTargetId());
			String taskRequire = OfficeUtil.getTaskRequire(dcSupTaskInfoRefine.getFeedbackWay(), dcSupTaskInfoRefine.getFeedbackRate());
			dcSupTaskInfo.setFeedbackWay(taskRequire);
			dcSupTaskInfo.setDcSupTaskInfoAddList(dcSupTaskInfoRefine.getDcSupTaskInfoAddList());

			dcSupTaskAudit.setDcSupTaskInfo(dcSupTaskInfo);
			return "modules/task/audit/dcSupTaskAuditFormRefine";
		}

		// 向页面加入审核实体
		model.addAttribute("dcSupTaskAudit", dcSupTaskAudit);
		// 默认位置，仅用于测试
		return "modules/task/audit/dcSupTaskAuditForm";
	}

	/**
	 * 保存数据
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:edit")
	@PostMapping(value = "save")
	@ResponseBody
	@RepeatSubmit
	public String save(@Validated DcSupTaskAudit dcSupTaskAudit) {
		String resultWord = dcSupTaskAuditService.saveAudit(dcSupTaskAudit);
		if (StringUtils.isBlank(resultWord)) {
			return renderResult(Global.TRUE, text("审核成功！"));
		} else {
			return renderResult(Global.FALSE, text(resultWord));
		}
	}
	
	/**
	 * 停用数据
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:edit")
	@RequestMapping(value = "disable")
	@ResponseBody
	public String disable(DcSupTaskAudit dcSupTaskAudit) {
		dcSupTaskAudit.setStatus(DcSupTaskAudit.STATUS_DISABLE);
		dcSupTaskAuditService.updateStatus(dcSupTaskAudit);
		return renderResult(Global.TRUE, text("停用任务过程审核信息成功"));
	}
	
	/**
	 * 启用数据
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:edit")
	@RequestMapping(value = "enable")
	@ResponseBody
	public String enable(DcSupTaskAudit dcSupTaskAudit) {
		dcSupTaskAudit.setStatus(DcSupTaskAudit.STATUS_NORMAL);
		dcSupTaskAuditService.updateStatus(dcSupTaskAudit);
		return renderResult(Global.TRUE, text("启用任务过程审核信息成功"));
	}
	
	/**
	 * 删除数据
	 */
	@RequiresPermissions("audit:dcSupTaskAudit:edit")
	@RequestMapping(value = "delete")
	@ResponseBody
	public String delete(DcSupTaskAudit dcSupTaskAudit) {
		dcSupTaskAuditService.delete(dcSupTaskAudit);
		return renderResult(Global.TRUE, text("删除任务过程审核表成功！"));
	}

	/**
	 * 任务部署审核列表
	 * @return
	 */
	@RequestMapping(value = "/queryAuditInfoListApp")
	@ResponseBody
	public Page<DcSupTaskAuditInfoApp> queryAuditInfoListApp(DcSupTaskAuditInfoApp auditInfo, HttpServletRequest request, HttpServletResponse response) {
		auditInfo.setPage(new Page<>(request, response));
		// 获取当前用户编号
		String userCode = UserUtils.getUser().getUserCode();
		// 过滤管理员
		if (!StringUtils.equals("system", userCode)) {
			auditInfo.setAuditorCode(userCode);
		}
		Page<DcSupTaskAuditInfoApp> page = dcSupTaskAuditService.queryAuditInfoListApp(auditInfo);
		return page;
	}

	/**
	 * 任务部署审核列表
	 * @return
	 */
	@RequestMapping(value = "/queryAuditFeedbackListApp")
	@ResponseBody
	public Page<DcSupTaskAuditFeedbackApp> queryAuditFeedbackListApp(DcSupTaskAuditFeedbackApp auditInfo, HttpServletRequest request, HttpServletResponse response) {
		auditInfo.setPage(new Page<>(request, response));
		// 获取当前用户编号
		String userCode = UserUtils.getUser().getUserCode();
		// 过滤管理员
		if (StringUtils.equals("system", userCode)) {
			auditInfo.setAuditorCode(null);
		}
		Page<DcSupTaskAuditFeedbackApp> page = dcSupTaskAuditService.queryAuditFeedbackListApp(auditInfo);
		return page;
	}

	@RequestMapping(value = "/queryAuditArrangeFormApp")
	@ResponseBody
	public String queryAuditArrangeFormApp(DcSupTaskAuditArrangeApp auditInfo) {
		DcSupTaskAuditArrangeApp form = dcSupTaskAuditService.queryAuditArrangeFormApp(auditInfo);
		return renderResult(Global.TRUE, text("查询成功！"),form);
	}

//	@RequestMapping(value = "/queryAuditArrangeListApp")
//	@ResponseBody
//	public Page<DcSupTaskAuditArrangeApp> queryAuditArrangeListApp(DcSupTaskAuditArrangeApp auditInfo, HttpServletRequest request, HttpServletResponse response) {
//		auditInfo.setPage(new Page<>(request, response));
//		// 获取当前用户编号
//		String userCode = UserUtils.getUser().getUserCode();
//		// 过滤管理员
//		if (!StringUtils.equals("system", userCode)) {
//			auditInfo.setAuditorCode(userCode);
//		}
//		Page<DcSupTaskAuditArrangeApp> page = dcSupTaskAuditService.queryAuditArrangeListApp(auditInfo);
//		return page;
//	}

	
}